home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_13_08 / phillip2 / hist.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-08-22  |  14.0 KB  |  543 lines
  1.  
  2.    /**************************************************
  3.    *
  4.    *   file d:\cips\hist.c
  5.    *
  6.    *   Functions: This file contains
  7.    *       calculate_histogram
  8.    *       calculate_histogram
  9.    *       zero_histogram
  10.    *       perform_histogram_equalization
  11.    *       show_histogram
  12.    *       print_histogram
  13.    *       smooth_histogram
  14.    *       display_histogram
  15.    *
  16.    *   Purpose: These functions calculate and display 
  17.    *      the histogram of an input image array.
  18.    *
  19.    *   Modifications:
  20.    *       July 86 - ported to IBM-PC
  21.    *       August 1990 - modified for use in the
  22.    *           C Image Processing System
  23.    *       March 1992 - removed the hardwired values
  24.    *           of 100 and replaced them with ROWS
  25.    *           and COLS.  There are still some
  26.    *           hardwired numbers in this file, but
  27.    *           they deal with displaying a histogram.
  28.    *       October 4, 1992 - added the smooth histogram
  29.    *           function.
  30.    *
  31.    **************************************************/
  32.  
  33. #include "cips.h"
  34.  
  35.  
  36. #define PRINT_WIDTH  80
  37. #define FORMFEED     '\014'
  38.  
  39.  
  40.  
  41.  
  42.           /*****************************************
  43.           *
  44.           *    perform_histogram_equalization(...
  45.           *
  46.           *    This function performs histogram
  47.           *    equalization on the input image array.
  48.           *
  49.           ******************************************/
  50.  
  51. perform_histogram_equalization(image, histogram,
  52.                                new_grays, area)
  53.    float new_grays, area;
  54.    short image[ROWS][COLS];
  55.    unsigned long histogram[];
  56. {
  57.    int i,
  58.        j,
  59.        k;
  60.    unsigned long sum,
  61.             sum_of_h[256];
  62.  
  63.    double constant;
  64.  
  65.    sum = 0;
  66.    for(i=0; i<256; i++){
  67.       sum         = sum + histogram[i];
  68.       sum_of_h[i] = sum;
  69.    }
  70.  
  71.       /* constant = new # of gray levels div by area */
  72.    constant = new_grays/area;
  73.    for(i=0; i<ROWS; i++){
  74.       for(j=0; j<COLS; j++){
  75.          k           = image[i][j];
  76.          image[i][j] = sum_of_h[k] * constant;
  77.       }
  78.    }
  79. }  /* ends perform_histogram_equalization */
  80.  
  81.  
  82.  
  83.  
  84.         /*****************************************
  85.         *
  86.         *   zero_histogram(...
  87.         *
  88.         *   This function clears or zeros a
  89.         *   histogram array.
  90.         *
  91.         ******************************************/
  92.  
  93. zero_histogram(histogram)
  94.    unsigned long histogram[];
  95. {
  96.    int i;
  97.    for(i=0; i<=GRAY_LEVELS; i++)
  98.       histogram[i] = 0;
  99. }  /* ends zero_histogram */
  100.  
  101.  
  102.  
  103.  
  104.         /*****************************************
  105.         *
  106.         *   calculate_histogram(...
  107.         *
  108.         *   This function calculates the histogram
  109.         *   for an input image arry.
  110.         *
  111.         ******************************************/
  112.  
  113. calculate_histogram(image, histogram)
  114.    short  image[ROWS][COLS];
  115.    unsigned long histogram[];
  116. {
  117.    int i,j,k;
  118.    for(i=0; i<ROWS; i++){
  119.       for(j=0; j<COLS; j++){
  120.          k = image[i][j];
  121.          histogram[k] = histogram[k] + 1;
  122.       }
  123.    }
  124. }  /* ends calculate_histogram */
  125.  
  126.  
  127.  
  128.  
  129.         /******************************************
  130.         *
  131.         *   show_histogram(histogram)
  132.         *
  133.         *   This function shows the histogram
  134.         *   on the screen as numbers and stars.
  135.         *
  136.         *******************************************/
  137.  
  138. show_histogram(histogram)
  139.         unsigned long histogram[];
  140. {
  141.         int     count,
  142.                 i,
  143.                 j;
  144.         unsigned long max, scale;
  145.  
  146.  
  147.         max   = 0;
  148.         count = 0;
  149.  
  150.         for(i=0; i<GRAY_LEVELS; i++)
  151.            if(histogram[i] > max)
  152.               max = histogram[i];
  153.  
  154.         if(max > (70 - 12))
  155.            scale = max/(70 - 12);
  156.         else
  157.            scale = 1;
  158.  
  159.         printf("\n max=%ld scale=%ld",max, scale);
  160.  
  161.         printf("\n\ngray    count");
  162.         printf("\nlevel");
  163.  
  164.         for(i=0; i<256; i++){
  165.            if(histogram[i] == 0)
  166.               ++count;
  167.            else
  168.               count = 0;
  169.  
  170.            if(count < 2){
  171.               printf("\n %4d: %7ld",i,histogram[i]);
  172.               for(j=0; j<((int)(histogram[i]/scale));
  173.                   j++){
  174.                  printf("*");
  175.               }   /* ends loop over j             */
  176.            }      /* ends if count < 5            */
  177.         }         /* ends loop over i GRAY_LEVELS */
  178. }       /* ends show_histogram */
  179.  
  180.  
  181.  
  182.         /*********************************************
  183.         *
  184.         *   print_histogram(histogram)
  185.         *
  186.         *   This function prints the histogram
  187.         *   input to the function.
  188.         *
  189.         **********************************************/
  190.  
  191. print_histogram(histogram, name)
  192.         char name[];
  193.         unsigned long histogram[];
  194. {
  195.         char    string[300],
  196.                 output[300];
  197.  
  198.         int     count,
  199.                 i,
  200.                 j,
  201.                 line_counter,
  202.                 print_counter;
  203.         unsigned long scale, max;
  204.  
  205.         FILE *printer;
  206.  
  207.         if( (printer = fopen("prn", "w")) == NULL)
  208.            printf("\nPH> Could not open printer");
  209.         else
  210.            printf("\nPH> The print file is opened");
  211.  
  212.         max           = 0;
  213.         count         = 0;
  214.         print_counter = 0;
  215.  
  216.         for(i=0; i<256; i++)
  217.            if(histogram[i] > max)
  218.               max = histogram[i];
  219.  
  220.         if(max > (PRINT_WIDTH - 12))
  221.            scale = max/(PRINT_WIDTH - 12);
  222.         else
  223.            scale = 1;
  224.  
  225.         printf("\n max=%ld scale=%ld",max, scale);
  226.  
  227.         printf("\nPI> Print header");
  228.         line_counter = 0;
  229.         hist_long_clear_buffer(string);
  230.         sprintf(string, 
  231.            "          This image is -- %s --\n", 
  232.            name);
  233.         fputs(string, printer);
  234.         ++line_counter;
  235.  
  236.         hist_long_clear_buffer(string);
  237.         sprintf(string, " \n");
  238.         fputs(string, printer);
  239.         ++line_counter;
  240.  
  241.         hist_long_clear_buffer(string);
  242.         sprintf(string, "          gray    count\n");
  243.         fputs(string, printer);
  244.         ++line_counter;
  245.         hist_long_clear_buffer(string);
  246.         sprintf(string, "          level\n");
  247.         fputs(string, printer);
  248.         ++line_counter;
  249.  
  250.         for(i=0; i<256; i++){
  251.            if(histogram[i] == 0)
  252.               ++count;
  253.            else
  254.               count = 0;
  255.  
  256.            if(count < 2){
  257.               printf(" %4d: %7ld",i,histogram[i]);
  258.               print_counter++;
  259.               if(print_counter >= 6){
  260.                  printf("\n");
  261.                  print_counter = 0;
  262.               }  /* ends if print_counter >= 6 */
  263.  
  264.               hist_long_clear_buffer(string);
  265.               sprintf(string,
  266.                 "           %3d: %7ld ->",
  267.                 i,histogram[i]);
  268.               fputs(string, printer);
  269.               hist_long_clear_buffer(string);
  270.               sprintf(output, " ");
  271.               for(j=0; j<((int)(histogram[i]/scale)); 
  272.                   j++){
  273.                  sprintf(string, "*");
  274.                  strcat(output, string);
  275.               }         /* ends loop over j */
  276.               fputs(string, printer); 
  277.               fputc('\n', printer);
  278.               ++line_counter;
  279.               if(line_counter >= 55){
  280.                  line_counter = 0;
  281.                  putc(FORMFEED, printer);
  282.               }  /* ends if line_counter >=55  */
  283.            }  /* ends if count < 2 */
  284.         }  /* ends loop over i */
  285.         putc(FORMFEED, printer);
  286.         fclose(printer);
  287.  
  288. }        /* ends print_histogram */
  289.  
  290.  
  291.  
  292.  
  293.         /*******************************************
  294.         *
  295.         *   display_histogram(histogram)
  296.         *
  297.         *   This function shows the histogram
  298.         *   input to the function.
  299.         *
  300.         ********************************************/
  301.  
  302. display_histogram(histogram, x, y,
  303.                   line_color, data_color)
  304.         int data_color, line_color, x, y;
  305.         unsigned long histogram[];
  306. {
  307.         int     count,
  308.                 i,
  309.                 j,
  310.                 length;
  311.         unsigned long scale, max;
  312.  
  313.         max   = 0;
  314.         count = 0;
  315.  
  316.         for(i=0; i<256; i++)
  317.            if(histogram[i] > max)
  318.               max = histogram[i];
  319.  
  320.         if(max > (200 - 12))
  321.            scale = max/(100 - 25);
  322.         else
  323.            scale = 1;
  324.  
  325.    /***************************
  326.    *
  327.    *   clear out an area for
  328.    *   this histogram display
  329.    *
  330.    ****************************/
  331.  
  332.         my_setcolor(line_color);
  333.         for(i=0; i<258; i++){
  334.            for(j=0; j<100; j++){
  335.               my_setpixel(x-1+i, y-j);
  336.            }
  337.         }
  338.  
  339.  
  340.          /***************************
  341.          *
  342.          *  draw the histogram axes
  343.          *
  344.          ****************************/
  345.  
  346.         my_setcolor(0);
  347.  
  348.         my_moveto(x, y);
  349.         my_lineto(x+255, y);
  350.         my_moveto(x, y);
  351.         my_lineto(x, y-95);
  352.         my_moveto(x+50, y);
  353.         my_lineto(x+50, y-95);
  354.         my_moveto(x+100, y);
  355.         my_lineto(x+100, y-95);
  356.         my_moveto(x+150, y);
  357.         my_lineto(x+150, y-95);
  358.         my_moveto(x+200, y);
  359.         my_lineto(x+200, y-95);
  360.         my_moveto(x+255, y);
  361.         my_lineto(x+255, y-95);
  362.  
  363.          /***************************
  364.          *
  365.          *  loop thru the histogram
  366.          *  and plot the scaled data
  367.          *
  368.          ****************************/
  369.  
  370.         my_setlinestyle(0xFFFF);
  371.         my_setcolor(data_color);
  372.  
  373.         for(i=0; i<256; i++){
  374.            if(histogram[i] != 0){
  375.               length = histogram[i]/scale;
  376.               my_moveto(x+i, y);
  377.               my_lineto(x+i, y-length);
  378.            }
  379.         }  /* ends loop over i GRAY_LEVELS */
  380. }  /* ends display_histogram */
  381.  
  382.  
  383.  
  384.  
  385.        /*****************************************
  386.        *
  387.        *   display_menu_for_histogram(...
  388.        *
  389.        *   This function shows the options
  390.        *   available for histogram function.
  391.        *
  392.        ****************************************/
  393.  
  394. display_menu_for_histogram(print, vertical, 
  395.                            horizontal)
  396.    int *print, *vertical, *horizontal;
  397. {
  398.    char response[80];
  399.    int  int_response, not_finished, r;
  400.  
  401.    not_finished = 1;
  402.    while(not_finished){
  403.       printf(
  404.       "\n\nHISTOGRAM> Enter choice (0 for no change)");
  405.       printf(
  406.       "\nHISTOGRAM> 1. print is %d (1=print 0=display)",
  407.          *print);
  408.       printf(
  409.       "\nHISTOGRAM> 2. # of vertical %dx%d areas %d",
  410.          ROWS, COLS, *vertical);
  411.       printf(
  412.       "\nHISTOGRAM> 3. # of horizontal %dx%d areas %d",
  413.          ROWS,COLS,*horizontal);
  414.       printf("\nHISTOGRAM> _\b");
  415.       get_integer(&r);
  416.  
  417.       if(r == 0)
  418.          not_finished = 0;
  419.  
  420.  
  421.       if(r == 1){
  422.          printf(
  423.             "\nHISTOGRAM> Enter 1 for print or 0 for display");
  424.          printf("\nHISTOGRAM> ___");
  425.          get_integer(&int_response);
  426.          *print = int_response;
  427.       }  /* ends if r == 1 */
  428.  
  429.       if(r == 2){
  430.       printf(
  431.      "\nHISTOGRAM> Enter # of vertical %dx%d areas ",
  432.             ROWS,COLS);
  433.          printf("\nHISTOGRAM> _\b");
  434.          get_integer(&int_response);
  435.          *vertical = int_response;
  436.       }  /* ends if r == 2  */
  437.  
  438.       if(r == 3){
  439.          printf(
  440.      "\nHISTOGRAM> Enter # of horizontal %dx%d areas ",
  441.           ROWS,COLS);
  442.          printf("\nHISTOGRAM> ___");
  443.          get_integer(&int_response);
  444.          *horizontal = int_response;
  445.       }  /* ends if r == 3 */
  446.  
  447.    }  /* ends while not_finished  */
  448. }  /* ends display_menu  */
  449.  
  450.  
  451.  
  452.  
  453.       /********************************************
  454.       *
  455.       *   calculate_area_histogram(...
  456.       *
  457.       *   This function calculates the histogram
  458.       *   for several ROWSxCOLS arrays of an
  459.       *   image.  The user inputs the number
  460.       *   of vertical and horizontal ROWSxCOLS
  461.       *   arrays to be histogramed.  This function
  462.       *   uses the image file name to read the image
  463.       *   arrays and calculate the overall
  464.       *   histogram.
  465.       *
  466.       *********************************************/
  467.  
  468. calculate_area_histogram(histogram, vertical, 
  469.                    horizontal, the_image, name, il, 
  470.                    ie, ll, le)
  471.    char     name[];
  472.    int      horizontal, il, ie, ll, le, vertical;
  473.    short    the_image[ROWS][COLS];
  474.    unsigned long histogram[];
  475. {
  476.    int count, i, j;
  477.  
  478.    printf("\nCalculating histograms");
  479.    zero_histogram(histogram);
  480.    count = 1;
  481.  
  482.    for(i=0; i<vertical; i++){
  483.       for(j=0; j<horizontal; j++){
  484.          printf("\n\tcalculating %d of %d",
  485.                count, horizontal*vertical);
  486.          read_tiff_image(name, the_image,
  487.                il+i*ROWS, ie+j*COLS, 
  488.                ll+i*ROWS, le+j*COLS);
  489.          calculate_histogram(the_image, histogram);
  490.          count++;
  491.       }  /* ends loop over j */
  492.    }  /* ends loop over i */
  493.  
  494. }  /* calcualte_area_histogram */
  495.  
  496.  
  497.  
  498.       /********************************************
  499.       *
  500.       *   smooth_histogram(...
  501.       *
  502.       *   This function smoothes the input histogram
  503.       *   and returns it.  It uses a simple averaging
  504.       *   scheme where each point in the histogram
  505.       *   is replaced by the average of itself and
  506.       *   the two points on either side of it.
  507.       *
  508.       *********************************************/
  509.  
  510. smooth_histogram(histogram)
  511.    unsigned long histogram[];
  512. {
  513.    int i;
  514.    unsigned long new_hist[GRAY_LEVELS+1];
  515.  
  516.    zero_histogram(new_hist);
  517.  
  518.    new_hist[0] = (histogram[0] + histogram[1])/2;
  519.    new_hist[GRAY_LEVELS] =
  520.       (histogram[GRAY_LEVELS] +
  521.        histogram[GRAY_LEVELS-1])/2;
  522.  
  523.    for(i=1; i<GRAY_LEVELS; i++){
  524.       new_hist[i] = (histogram[i-1] +
  525.                      histogram[i]   +
  526.                      histogram[i+1])/3;
  527.    }
  528.  
  529.    for(i=0; i<=GRAY_LEVELS; i++)
  530.       histogram[i] = new_hist[i];
  531.  
  532. }  /* ends smooth_histogram */
  533.  
  534.  
  535.  
  536. hist_long_clear_buffer(string)
  537.    char string[];
  538. {
  539.    int i;
  540.    for(i=0; i<300; i++)
  541.       string[i] = ' ';
  542. }
  543.